fix(bt): Fix slow speed & stat chart hover issue - #129

Check if this issue is valid — if so, understand the root cause and fix it. At src-tauri/risuko-engine/src/engine/torrent.rs, line 382:

<comment>Magnet resolution requests with different options can interfere when they target the same info-hash, because cache singleflight is keyed only by info-hash. Consider including resolver-affecting inputs (at least timeout/tracker/encryption context) in the singleflight key, or limiting singleflight to byte caching after a successful resolve.</comment>

<file context>
@@ -234,51 +339,106 @@ impl TorrentEngine {
+        };
+
+        let resolved = match info_hash_key {
+            Some(key) => self.magnet_cache.get_or_resolve(key, resolve).await?,
+            None => Arc::new(resolve().await?),
+        };
</file context>

Check if this issue is valid — if so, understand the root cause and fix it. At src-tauri/src/cli/headless.rs, line 16:

<comment>If tracing was already initialized before start_headless_engine() runs, `try_init()` silently fails and the headless-specific logging config (stderr output, diag/risuko_bt debug levels) is discarded with no indication. Consider logging a `tracing::warn!` or `eprintln!` when try_init() returns Err so operators know the headless logging config isn't active.</comment>

<file context>
@@ -9,11 +9,24 @@ use risuko_engine::engine::manager::TaskManager;
+    use tracing_subscriber::EnvFilter;
+    let filter = EnvFilter::try_from_default_env()
+        .unwrap_or_else(|_| EnvFilter::new("info,diag=debug,risuko_bt=debug,risuko_engine=info"));
+    let _ = tracing_subscriber::fmt()
+        .with_env_filter(filter)
+        .with_writer(std::io::stderr)
</file context>

Check if this issue is valid — if so, understand the root cause and fix it. At src-tauri/risuko-bt/src/wire/extended.rs, line 171:

<comment>Peer `reqq` values above `u32::MAX` currently wrap during decode instead of being rejected, so invalid large handshakes can be interpreted as a very small request window. Using a checked conversion here keeps handshake parsing consistent with the intended positive-cap semantics and avoids accidental pipeline throttling.</comment>

<file context>
@@ -166,11 +164,17 @@ impl ExtHandshake {
+            .iter()
+            .find(|(k, _)| k == b"reqq")
+            .and_then(|(_, v)| v.as_int())
+            .and_then(|n| if n > 0 { Some(n as u32) } else { None });
         Some(Self {
             supported,
</file context>

Check if this issue is valid — if so, understand the root cause and fix it. At src-tauri/risuko-bt/src/tracker/udp.rs, line 37:

<comment>A tracker announce can now be sent to multiple resolved endpoints for the same request before the first success aborts the remaining tasks. For Started/Completed/Stopped events this can duplicate state-changing updates; consider racing only the connect phase or using a staggered/first-success strategy that does not issue parallel announces.</comment>

<file context>
@@ -24,11 +26,49 @@ const ACTION_ERROR: u32 = 3;
+    let mut attempts = JoinSet::new();
+    for target in targets {
+        let req = req.clone();
+        attempts.spawn(async move { announce_endpoint(target, &req).await });
+    }
+
</file context>

Check if this issue is valid — if so, understand the root cause and fix it. At src-tauri/risuko-bt/src/bencode.rs, line 336:

<comment>Untrusted bencode dictionaries can now include duplicate keys and still parse successfully, leaving downstream code to resolve ambiguous fields by access pattern. Consider relaxing key ordering for external payloads while still rejecting duplicate keys here.</comment>

<file context>
@@ -234,34 +311,36 @@ impl<'a> Parser<'a> {
-            if let Some((prev, _)) = items.last() {
-                if prev.as_slice() >= key.as_slice() {
-                    return Err(Error::BadDictOrder(key_pos));
+            if self.dict_mode == DictMode::Canonical {
+                if let Some((prev, _)) = items.last() {
+                    if prev.as_slice() >= key.as_slice() {
</file context>

Check if this issue is valid — if so, understand the root cause and fix it. At src-tauri/risuko-bt/src/peer/connection.rs, line 202:

<comment>Identity-failure suppression is brittle because it depends on one exact error string for info-hash mismatch. Using an exact match here misses existing variants (for example MSE mismatch messages), so the code can perform avoidable fallback dials and extra reconnect delay.</comment>

<file context>
@@ -124,37 +124,84 @@ pub async fn connect_utp_plaintext(
 
+fn alternate_dial_cannot_help(err: &std::io::Error) -> bool {
+    let message = err.to_string();
+    message == "info hash mismatch" || message.starts_with("self-connection ")
+}
+
</file context>

Check if this issue is valid — if so, understand the root cause and fix it. At src-tauri/risuko-bt/src/magnet.rs, line 159:

<comment>Magnet trackers with a literal comma in their URL can be corrupted before announce, because decoded `tr=` values are passed through `expand_tracker_entries` and split on `,`. Consider only applying comma/newline expansion to caller-supplied tracker lists, while preserving each magnet `tr` parameter as one URL.</comment>

<file context>
@@ -34,73 +30,146 @@ const OUR_UT_PEX_ID: u8 = 4;
-        if !trackers.iter().any(|x| x == t) {
-            trackers.push(t.clone());
+    let mut trackers: Vec<String> = Vec::new();
+    for t in magnet.trackers.iter().chain(extra_trackers.iter()) {
+        for part in expand_tracker_entries(t) {
+            if !trackers.iter().any(|x| x == &part) {
</file context>

Check if this issue is valid — if so, understand the root cause and fix it. At src-tauri/risuko-bt/src/magnet.rs, line 457:

<comment>Peer discovery can drop legitimate peers in non-Cloudflare parts of these address blocks, because several CIDR checks only compare the first two octets despite narrower ranges. Narrow the checks to the actual prefix before using this as a global dial filter.</comment>

<file context>
@@ -306,6 +414,66 @@ pub async fn resolve_with_peers(
+    }
+}
+
+fn is_cloudflare_v4(ip: std::net::Ipv4Addr) -> bool {
+    let o = ip.octets();
+    matches!(
</file context>

Check if this issue is valid — if so, understand the root cause and fix it. At src-tauri/risuko-bt/src/peer/connection.rs, line 1278:

<comment>The peer actor now tears down the socket without an explicit `shutdown()`, so a local disconnect or writer exit may not be observed promptly by the remote peer and any queued bytes rely on task drop instead of an orderly close.</comment>

<file context>
@@ -1234,15 +1269,16 @@ async fn writer_task(
         if disconnect {
-            let _ = writer.shutdown().await;
-            return;
+            return "local disconnect".into();
         }
     }
</file context>